pydaptivefiltering

133class AdaptiveFilter(ABC):
134    """Abstract base class for all adaptive filters.
135
136    Parameters
137    ----------
138    filter_order:
139        Order in the FIR sense (number of taps - 1). For non-FIR structures, it can be used
140        as a generic size indicator for base allocation.
141    w_init:
142        Initial coefficient vector. If None, initialized to zeros.
143
144    Notes
145    -----
146    - Subclasses should set `supports_complex = True` if they support complex-valued data.
147    - Subclasses are expected to call `_record_history()` every iteration (or use helper methods)
148      if they want coefficient trajectories.
149    """
150
151    supports_complex: bool = False
152
153    def __init__(self, filter_order: int, w_init: Optional[ArrayLike] = None) -> None:
154        self.filter_order: int = int(filter_order)
155        self._dtype = complex if self.supports_complex else float
156
157        self.regressor: np.ndarray = np.zeros(self.filter_order + 1, dtype=self._dtype)
158
159        if w_init is not None:
160            self.w: np.ndarray = np.asarray(w_init, dtype=self._dtype)
161        else:
162            self.w = np.zeros(self.filter_order + 1, dtype=self._dtype)
163
164        self.w_history: List[np.ndarray] = []
165        self._record_history()
166
167    def _record_history(self) -> None:
168        """Store a snapshot of current coefficients."""
169        self.w_history.append(np.asarray(self.w).copy())
170
171    def _final_coeffs(self, coefficients: Any) -> Any:
172        """Return last coefficients from a history container (list or 2D array)."""
173        if coefficients is None:
174            return None
175        if isinstance(coefficients, list) and len(coefficients) > 0:
176            return coefficients[-1]
177        try:
178            a = np.asarray(coefficients)
179            if a.ndim == 2:
180                return a[-1, :]
181        except Exception:
182            pass
183        return coefficients
184
185    def _pack_results(
186        self,
187        outputs: np.ndarray,
188        errors: np.ndarray,
189        runtime_s: float,
190        error_type: str = "a_priori",
191        extra: Optional[Dict[str, Any]] = None,
192    ) -> OptimizationResult:
193        """Centralized output packaging to standardize results."""
194        return OptimizationResult(
195            outputs=np.asarray(outputs),
196            errors=np.asarray(errors),
197            coefficients=np.asarray(self.w_history),
198            algorithm=self.__class__.__name__,
199            runtime_ms=float(runtime_s) * 1000.0,
200            error_type=str(error_type),
201            extra=extra,
202        )
203
204    def filter_signal(self, input_signal: ArrayLike) -> np.ndarray:
205        """Filter an input signal using current coefficients.
206
207        Default implementation assumes an FIR structure with taps `self.w` and
208        regressor convention:
209            x_k = [x[k], x[k-1], ..., x[k-m]]
210        and output:
211            y[k] = w^H x_k   (Hermitian for complex)
212        """
213        x = np.asarray(input_signal, dtype=self._dtype)
214        n_samples = x.size
215        y = np.zeros(n_samples, dtype=self._dtype)
216
217        x_padded = np.zeros(n_samples + self.filter_order, dtype=self._dtype)
218        x_padded[self.filter_order:] = x
219
220        for k in range(n_samples):
221            x_k = x_padded[k : k + self.filter_order + 1][::-1]
222            y[k] = np.dot(self.w.conj(), x_k)
223
224        return y
225
226    @classmethod
227    def default_test_init_kwargs(cls, order: int) -> dict:
228        """Override in subclasses to provide init kwargs for standardized tests."""
229        return {}
230
231    @abstractmethod
232    def optimize(
233        self,
234        input_signal: ArrayLike,
235        desired_signal: ArrayLike,
236        **kwargs: Any,
237    ) -> Any:
238        """Run the adaptation procedure.
239
240        Subclasses should return either:
241        - OptimizationResult (recommended), or
242        - dict-like with standardized keys, if you are migrating older code.
243        """
244        raise NotImplementedError
245
246    def reset_filter(self, w_new: Optional[ArrayLike] = None) -> None:
247        """Reset coefficients and history."""
248        if w_new is not None:
249            self.w = np.asarray(w_new, dtype=self._dtype)
250        else:
251            self.w = np.zeros(self.filter_order + 1, dtype=self._dtype)
252        self.w_history = []
253        self._record_history()

 27class LMS(AdaptiveFilter):
 28    """
 29    Complex Least-Mean Squares (LMS) adaptive filter.
 30
 31    Standard complex LMS algorithm for adaptive FIR filtering, following Diniz
 32    (Alg. 3.2). The method performs a stochastic-gradient update using the
 33    instantaneous a priori error.
 34
 35    Parameters
 36    ----------
 37    filter_order : int
 38        Adaptive FIR filter order ``M``. The number of coefficients is ``M + 1``.
 39    step_size : float, optional
 40        Adaptation step size ``mu``. Default is 1e-2.
 41    w_init : array_like of complex, optional
 42        Initial coefficient vector ``w(0)`` with shape ``(M + 1,)``. If None,
 43        initializes with zeros.
 44
 45    Notes
 46    -----
 47    At iteration ``k``, form the regressor vector (newest sample first):
 48
 49    .. math::
 50        x_k = [x[k], x[k-1], \\ldots, x[k-M]]^T \\in \\mathbb{C}^{M+1}.
 51
 52    The a priori output and error are
 53
 54    .. math::
 55        y[k] = w^H[k] x_k, \\qquad e[k] = d[k] - y[k],
 56
 57    and the LMS update is
 58
 59    .. math::
 60        w[k+1] = w[k] + \\mu\\, e^*[k] \\, x_k.
 61
 62    This implementation:
 63        - uses complex arithmetic (``supports_complex=True``),
 64        - returns the a priori error ``e[k]``,
 65        - records coefficient history via the base class.
 66
 67    References
 68    ----------
 69    .. [1] P. S. R. Diniz, *Adaptive Filtering: Algorithms and Practical
 70       Implementation*, 5th ed., Algorithm 3.2.
 71    """
 72
 73    supports_complex: bool = True
 74
 75    step_size: float
 76
 77    def __init__(
 78        self,
 79        filter_order: int,
 80        step_size: float = 1e-2,
 81        w_init: Optional[ArrayLike] = None,
 82    ) -> None:
 83        super().__init__(filter_order=int(filter_order), w_init=w_init)
 84        self.step_size = float(step_size)
 85
 86    @validate_input
 87    def optimize(
 88        self,
 89        input_signal: np.ndarray,
 90        desired_signal: np.ndarray,
 91        verbose: bool = False,
 92    ) -> OptimizationResult:
 93        """
 94        Executes the LMS adaptation loop over paired input/desired sequences.
 95
 96        Parameters
 97        ----------
 98        input_signal : array_like of complex
 99            Input sequence ``x[k]`` with shape ``(N,)`` (will be flattened).
100        desired_signal : array_like of complex
101            Desired sequence ``d[k]`` with shape ``(N,)`` (will be flattened).
102        verbose : bool, optional
103            If True, prints the total runtime after completion.
104
105        Returns
106        -------
107        OptimizationResult
108            Result object with fields:
109            - outputs : ndarray of complex, shape ``(N,)``
110                Scalar output sequence, ``y[k] = w^H[k] x_k``.
111            - errors : ndarray of complex, shape ``(N,)``
112                Scalar a priori error sequence, ``e[k] = d[k] - y[k]``.
113            - coefficients : ndarray of complex
114                Coefficient history recorded by the base class.
115            - error_type : str
116                Set to ``"a_priori"``.
117        """
118        tic: float = perf_counter()
119
120        x: np.ndarray = np.asarray(input_signal, dtype=complex).ravel()
121        d: np.ndarray = np.asarray(desired_signal, dtype=complex).ravel()
122
123        n_samples: int = int(x.size)
124        m: int = int(self.filter_order)
125
126        outputs: np.ndarray = np.zeros(n_samples, dtype=complex)
127        errors: np.ndarray = np.zeros(n_samples, dtype=complex)
128
129        x_padded: np.ndarray = np.zeros(n_samples + m, dtype=complex)
130        x_padded[m:] = x
131
132        for k in range(n_samples):
133            x_k: np.ndarray = x_padded[k : k + m + 1][::-1]
134
135            y_k: complex = complex(np.vdot(self.w, x_k)) 
136            outputs[k] = y_k
137    
138            e_k: complex = d[k] - y_k
139            errors[k] = e_k
140
141            self.w = self.w + self.step_size * np.conj(e_k) * x_k
142
143            self._record_history()
144
145        runtime_s: float = perf_counter() - tic
146        if verbose:
147            print(f"[LMS] Completed in {runtime_s * 1000:.03f} ms")
148
149        return self._pack_results(
150            outputs=outputs,
151            errors=errors,
152            runtime_s=runtime_s,
153            error_type="a_priori",
154        )

 27class NLMS(AdaptiveFilter):
 28    """
 29    Complex Normalized Least-Mean Squares (NLMS) adaptive filter.
 30
 31    Normalized LMS algorithm for adaptive FIR filtering, following Diniz
 32    (Alg. 4.3). The method normalizes the step size by the instantaneous
 33    regressor energy to improve stability and reduce sensitivity to input
 34    scaling.
 35
 36    Parameters
 37    ----------
 38    filter_order : int
 39        Adaptive FIR filter order ``M``. The number of coefficients is ``M + 1``.
 40    step_size : float, optional
 41        Base adaptation step size ``mu``. Default is 1e-2.
 42    gamma : float, optional
 43        Regularization constant ``gamma`` used in the normalization denominator
 44        to avoid division by zero (or near-zero regressor energy). Default is 1e-6.
 45    w_init : array_like of complex, optional
 46        Initial coefficient vector ``w(0)`` with shape ``(M + 1,)``. If None,
 47        initializes with zeros.
 48
 49    Notes
 50    -----
 51    At iteration ``k``, form the regressor vector (newest sample first):
 52
 53    .. math::
 54        x_k = [x[k], x[k-1], \\ldots, x[k-M]]^T \\in \\mathbb{C}^{M+1}.
 55
 56    The a priori output and error are
 57
 58    .. math::
 59        y[k] = w^H[k] x_k, \\qquad e[k] = d[k] - y[k].
 60
 61    Define the instantaneous regressor energy
 62
 63    .. math::
 64        \\|x_k\\|^2 = x_k^H x_k,
 65
 66    and the normalized step size
 67
 68    .. math::
 69        \\mu_k = \\frac{\\mu}{\\|x_k\\|^2 + \\gamma}.
 70
 71    The NLMS update is then
 72
 73    .. math::
 74        w[k+1] = w[k] + \\mu_k\\, e^*[k] \\, x_k.
 75
 76    This implementation:
 77        - uses complex arithmetic (``supports_complex=True``),
 78        - returns the a priori error ``e[k]``,
 79        - records coefficient history via the base class.
 80
 81    References
 82    ----------
 83    .. [1] P. S. R. Diniz, *Adaptive Filtering: Algorithms and Practical
 84       Implementation*, 5th ed., Algorithm 4.3.
 85    """
 86
 87    supports_complex: bool = True
 88
 89    step_size: float
 90    gamma: float
 91
 92    def __init__(
 93        self,
 94        filter_order: int,
 95        step_size: float = 1e-2,
 96        gamma: float = 1e-6,
 97        w_init: Optional[ArrayLike] = None,
 98    ) -> None:
 99        super().__init__(filter_order=int(filter_order), w_init=w_init)
100        self.step_size = float(step_size)
101        self.gamma = float(gamma)
102
103    @validate_input
104    def optimize(
105        self,
106        input_signal: np.ndarray,
107        desired_signal: np.ndarray,
108        verbose: bool = False,
109    ) -> OptimizationResult:
110        """
111        Executes the NLMS adaptation loop over paired input/desired sequences.
112
113        Parameters
114        ----------
115        input_signal : array_like of complex
116            Input sequence ``x[k]`` with shape ``(N,)`` (will be flattened).
117        desired_signal : array_like of complex
118            Desired sequence ``d[k]`` with shape ``(N,)`` (will be flattened).
119        verbose : bool, optional
120            If True, prints the total runtime after completion.
121
122        Returns
123        -------
124        OptimizationResult
125            Result object with fields:
126            - outputs : ndarray of complex, shape ``(N,)``
127                Scalar output sequence, ``y[k] = w^H[k] x_k``.
128            - errors : ndarray of complex, shape ``(N,)``
129                Scalar a priori error sequence, ``e[k] = d[k] - y[k]``.
130            - coefficients : ndarray of complex
131                Coefficient history recorded by the base class.
132            - error_type : str
133                Set to ``"a_priori"``.
134        """
135        tic: float = perf_counter()
136
137        x: np.ndarray = np.asarray(input_signal, dtype=complex).ravel()
138        d: np.ndarray = np.asarray(desired_signal, dtype=complex).ravel()
139
140        n_samples: int = int(x.size)
141        m: int = int(self.filter_order)
142
143        outputs: np.ndarray = np.zeros(n_samples, dtype=complex)
144        errors: np.ndarray = np.zeros(n_samples, dtype=complex)
145
146        x_padded: np.ndarray = np.zeros(n_samples + m, dtype=complex)
147        x_padded[m:] = x
148
149        for k in range(n_samples):
150            x_k: np.ndarray = x_padded[k : k + m + 1][::-1]
151
152            y_k: complex = complex(np.vdot(self.w, x_k))
153            outputs[k] = y_k
154
155            e_k: complex = d[k] - y_k
156            errors[k] = e_k
157
158            norm_xk: float = float(np.vdot(x_k, x_k).real)
159            mu_k: float = self.step_size / (norm_xk + self.gamma)
160
161            self.w = self.w + mu_k * np.conj(e_k) * x_k
162
163            self._record_history()
164
165        runtime_s: float = perf_counter() - tic
166        if verbose:
167            print(f"[NLMS] Completed in {runtime_s * 1000:.03f} ms")
168
169        return self._pack_results(
170            outputs=outputs,
171            errors=errors,
172            runtime_s=runtime_s,
173            error_type="a_priori",
174        )

 26class AffineProjection(AdaptiveFilter):
 27    """
 28    Complex Affine-Projection Algorithm (APA) adaptive filter.
 29
 30    Affine-projection LMS-type algorithm that reuses the last ``L+1`` regressor
 31    vectors to accelerate convergence relative to LMS/NLMS, following Diniz
 32    (Alg. 4.6). Per iteration, the method solves a small linear system of size
 33    ``(L+1) x (L+1)``.
 34
 35    Parameters
 36    ----------
 37    filter_order : int
 38        Adaptive FIR filter order ``M``. The number of coefficients is ``M + 1``.
 39    step_size : float, optional
 40        Adaptation step size (relaxation factor) ``mu``. Default is 1e-2.
 41    gamma : float, optional
 42        Diagonal loading (regularization) ``gamma`` applied to the projection
 43        correlation matrix for numerical stability. Default is 1e-6.
 44    L : int, optional
 45        Reuse factor (projection order). The algorithm uses ``L + 1`` most recent
 46        regressors. Default is 2.
 47    w_init : array_like of complex, optional
 48        Initial coefficient vector ``w(0)`` with shape ``(M + 1,)``. If None,
 49        initializes with zeros.
 50
 51    Notes
 52    -----
 53    At iteration ``k``, form the projection matrix and desired vector:
 54
 55    - ``X(k) ∈ C^{(L+1) x (M+1)}``, whose rows are regressor vectors, with the most
 56      recent regressor at row 0.
 57    - ``d_vec(k) ∈ C^{L+1}``, stacking the most recent desired samples, with
 58      ``d[k]`` at index 0.
 59
 60    The projection output and error vectors are:
 61
 62    .. math::
 63        y_{vec}(k) = X(k)\\,w^*(k) \\in \\mathbb{C}^{L+1},
 64
 65    .. math::
 66        e_{vec}(k) = d_{vec}(k) - y_{vec}(k).
 67
 68    The update direction ``u(k)`` is obtained by solving the regularized system:
 69
 70    .. math::
 71        (X(k)X^H(k) + \\gamma I_{L+1})\\,u(k) = e_{vec}(k),
 72
 73    and the coefficient update is:
 74
 75    .. math::
 76        w(k+1) = w(k) + \\mu X^H(k)\\,u(k).
 77
 78    This implementation returns only the *most recent* scalar components:
 79
 80    - ``y[k] = y_vec(k)[0]``
 81    - ``e[k] = e_vec(k)[0]``
 82
 83    References
 84    ----------
 85    .. [1] P. S. R. Diniz, *Adaptive Filtering: Algorithms and Practical
 86       Implementation*, 5th ed., Algorithm 4.6.
 87    """
 88
 89    supports_complex: bool = True
 90
 91    step_size: float
 92    gamma: float
 93    memory_length: int
 94
 95    def __init__(
 96        self,
 97        filter_order: int,
 98        step_size: float = 1e-2,
 99        gamma: float = 1e-6,
100        L: int = 2,
101        w_init: Optional[ArrayLike] = None,
102    ) -> None:
103        super().__init__(filter_order=int(filter_order), w_init=w_init)
104        self.step_size = float(step_size)
105        self.gamma = float(gamma)
106        self.memory_length = int(L)
107
108    @validate_input
109    def optimize(
110        self,
111        input_signal: np.ndarray,
112        desired_signal: np.ndarray,
113        verbose: bool = False,
114        return_internal_states: bool = False,
115    ) -> OptimizationResult:
116        """
117        Executes the Affine Projection adaptation loop over paired input/desired sequences.
118
119        Parameters
120        ----------
121        input_signal : array_like of complex
122            Input sequence ``x[k]`` with shape ``(N,)`` (will be flattened).
123        desired_signal : array_like of complex
124            Desired sequence ``d[k]`` with shape ``(N,)`` (will be flattened).
125        verbose : bool, optional
126            If True, prints the total runtime after completion.
127        return_internal_states : bool, optional
128            If True, includes the last internal states in ``result.extra``:
129            ``"last_regressor_matrix"`` (``X(k)``) and
130            ``"last_correlation_matrix"`` (``X(k)X^H(k) + gamma I``).
131
132        Returns
133        -------
134        OptimizationResult
135            Result object with fields:
136            - outputs : ndarray of complex, shape ``(N,)``
137                Scalar output sequence, ``y[k] = y_vec(k)[0]``.
138            - errors : ndarray of complex, shape ``(N,)``
139                Scalar a priori error sequence, ``e[k] = e_vec(k)[0]``.
140            - coefficients : ndarray of complex
141                Coefficient history recorded by the base class.
142            - error_type : str
143                Set to ``"a_priori"``.
144            - extra : dict, optional
145                Present only if ``return_internal_states=True``.
146        """
147        tic: float = perf_counter()
148
149        dtype = complex
150        x = np.asarray(input_signal, dtype=dtype).ravel()
151        d = np.asarray(desired_signal, dtype=dtype).ravel()
152        
153        n_samples: int = int(x.size)
154        m: int = int(self.filter_order)
155        L: int = int(self.memory_length)
156
157        outputs: np.ndarray = np.zeros(n_samples, dtype=dtype)
158        errors: np.ndarray = np.zeros(n_samples, dtype=dtype)
159
160        x_padded: np.ndarray = np.zeros(n_samples + m, dtype=dtype)
161        x_padded[m:] = x
162
163        X_matrix: np.ndarray = np.zeros((L + 1, m + 1), dtype=dtype)
164        D_vector: np.ndarray = np.zeros(L + 1, dtype=dtype)
165
166        last_corr: Optional[np.ndarray] = None
167
168        eye_L: np.ndarray = np.eye(L + 1, dtype=dtype)
169
170        for k in range(n_samples):
171            X_matrix[1:] = X_matrix[:-1]
172            X_matrix[0] = x_padded[k : k + m + 1][::-1]
173
174            D_vector[1:] = D_vector[:-1]
175            D_vector[0] = d[k]
176
177            Y_vector: np.ndarray = X_matrix @ self.w.conj()
178            E_vector: np.ndarray = D_vector - Y_vector
179
180            outputs[k] = Y_vector[0]
181            errors[k] = E_vector[0]
182
183            corr_matrix: np.ndarray = (X_matrix @ X_matrix.conj().T) + (self.gamma * eye_L)
184            last_corr = corr_matrix
185
186            try:
187                u: np.ndarray = np.linalg.solve(corr_matrix, E_vector)
188            except np.linalg.LinAlgError:
189                u = np.linalg.pinv(corr_matrix) @ E_vector
190
191            self.w = self.w + self.step_size * (X_matrix.T @ u.conj())
192            self._record_history()
193
194        runtime_s: float = perf_counter() - tic
195        if verbose:
196            print(f"[AffineProjection] Completed in {runtime_s * 1000:.02f} ms")
197
198        extra = None
199        if return_internal_states:
200            extra = {
201                "last_regressor_matrix": X_matrix.copy(),
202                "last_correlation_matrix": None if last_corr is None else last_corr.copy(),
203            }
204
205        return self._pack_results(
206            outputs=outputs,
207            errors=errors,
208            runtime_s=runtime_s,
209            error_type="a_priori",
210            extra=extra,
211        )

 27class SignData(AdaptiveFilter):
 28    """
 29    Complex Sign-Data LMS adaptive filter.
 30
 31    Low-complexity LMS variant in which the regressor vector is replaced by its
 32    element-wise sign. This reduces multiplications (since the update uses a
 33    ternary/sign regressor), at the expense of slower convergence and/or larger
 34    steady-state misadjustment in many scenarios.
 35
 36    Parameters
 37    ----------
 38    filter_order : int
 39        Adaptive FIR filter order ``M``. The number of coefficients is ``M + 1``.
 40    step_size : float, optional
 41        Adaptation step size ``mu``. Default is 1e-2.
 42    w_init : array_like of complex, optional
 43        Initial coefficient vector ``w(0)`` with shape ``(M + 1,)``. If None,
 44        initializes with zeros.
 45
 46    Notes
 47    -----
 48    At iteration ``k``, form the regressor vector (newest sample first):
 49
 50    .. math::
 51        x_k = [x[k], x[k-1], \\ldots, x[k-M]]^T \\in \\mathbb{C}^{M+1}.
 52
 53    The a priori output and error are
 54
 55    .. math::
 56        y[k] = w^H[k] x_k, \\qquad e[k] = d[k] - y[k].
 57
 58    Define the element-wise sign regressor ``\\operatorname{sign}(x_k)``.
 59    The update implemented here is
 60
 61    .. math::
 62        w[k+1] = w[k] + 2\\mu\\, e^*[k] \\, \\operatorname{sign}(x_k).
 63
 64    Implementation details
 65        - For complex inputs, ``numpy.sign`` applies element-wise and returns
 66          ``x/|x|`` when ``x != 0`` and ``0`` when ``x == 0``.
 67        - The factor ``2`` in the update matches the implementation in this
 68          module (consistent with common LMS gradient conventions).
 69
 70    References
 71    ----------
 72    .. [1] P. S. R. Diniz, *Adaptive Filtering: Algorithms and Practical
 73       Implementation*, 5th ed., Algorithm 4.1 (sign-based LMS variants).
 74    """
 75
 76    supports_complex: bool = True
 77
 78    def __init__(
 79        self,
 80        filter_order: int,
 81        step_size: float = 1e-2,
 82        w_init: Optional[ArrayLike] = None,
 83    ) -> None:
 84        super().__init__(filter_order=int(filter_order), w_init=w_init)
 85        self.step_size = float(step_size)
 86
 87    @validate_input
 88    def optimize(
 89        self,
 90        input_signal: np.ndarray,
 91        desired_signal: np.ndarray,
 92        verbose: bool = False,
 93        return_internal_states: bool = False,
 94    ) -> OptimizationResult:
 95        """
 96        Executes the Sign-Data LMS adaptation loop over paired input/desired sequences.
 97
 98        Parameters
 99        ----------
100        input_signal : array_like of complex
101            Input sequence ``x[k]`` with shape ``(N,)`` (will be flattened).
102        desired_signal : array_like of complex
103            Desired sequence ``d[k]`` with shape ``(N,)`` (will be flattened).
104        verbose : bool, optional
105            If True, prints the total runtime after completion.
106        return_internal_states : bool, optional
107            If True, includes the last internal state in ``result.extra``:
108            ``"last_sign_regressor"`` (``sign(x_k)``).
109
110        Returns
111        -------
112        OptimizationResult
113            Result object with fields:
114            - outputs : ndarray of complex, shape ``(N,)``
115                Scalar output sequence, ``y[k] = w^H[k] x_k``.
116            - errors : ndarray of complex, shape ``(N,)``
117                Scalar a priori error sequence, ``e[k] = d[k] - y[k]``.
118            - coefficients : ndarray of complex
119                Coefficient history recorded by the base class.
120            - error_type : str
121                Set to ``"a_priori"``.
122            - extra : dict, optional
123                Present only if ``return_internal_states=True``.
124        """
125        t0 = perf_counter()
126
127        x = np.asarray(input_signal, dtype=complex).ravel()
128        d = np.asarray(desired_signal, dtype=complex).ravel()
129
130        n_samples = int(x.size)
131        m = int(self.filter_order)
132
133        outputs = np.zeros(n_samples, dtype=complex)
134        errors = np.zeros(n_samples, dtype=complex)
135
136        x_padded = np.zeros(n_samples + m, dtype=complex)
137        x_padded[m:] = x
138
139        last_sign_xk: Optional[np.ndarray] = None
140
141        for k in range(n_samples):
142            x_k = x_padded[k : k + m + 1][::-1]
143
144            y_k = complex(np.vdot(self.w, x_k))
145            outputs[k] = y_k
146
147            e_k = d[k] - y_k
148            errors[k] = e_k
149
150            sign_xk = np.sign(x_k)
151            last_sign_xk = sign_xk
152
153            self.w = self.w + (2.0 * self.step_size) * np.conj(e_k) * sign_xk
154            self._record_history()
155
156        runtime_s = float(perf_counter() - t0)
157        if verbose:
158            print(f"[SignData] Completed in {runtime_s * 1000:.03f} ms")
159
160        extra: Optional[Dict[str, Any]] = None
161        if return_internal_states:
162            extra = {"last_sign_regressor": None if last_sign_xk is None else last_sign_xk.copy()}
163
164        return self._pack_results(
165            outputs=outputs,
166            errors=errors,
167            runtime_s=runtime_s,
168            error_type="a_priori",
169            extra=extra,
170        )